package ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.init;

import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.util.List;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Camino;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Carro;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Configuracion;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Descanso;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.EnumEvento;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.EnumSentido;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Esclusa;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Evento;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Infraestructura;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.modelo.Sensor;
import ar.uba.fi.cimII7566.cuat201102.automatizacionNegroHumo.negocio.Simulador;

public class AutomatizacionNegroHumoApplet extends JApplet implements
	ActionListener {
	private static final long serialVersionUID = 8453044237960020514L;
	private SimulacionPanel comp;
	private Simulador simulador;
	private JTextArea textArea = new JTextArea();
	private static final String SEPARADOR2 = "---------------------------------------";

	public AutomatizacionNegroHumoApplet(Simulador sim) {
		this.simulador = sim;
	}

	public void init() {
		GridBagLayout layOut = new GridBagLayout();
		getContentPane().setLayout(layOut);

		agregarPanelSimulacion(layOut);
		agregarPanelInformacion(layOut);
		validate();
	}

	public void actualizar() {
		calcularTextArea();
		comp.repaint();
		textArea.repaint();
	}

	private void agregarPanelInformacion(GridBagLayout layOut) {
		calcularTextArea();

		GridBagConstraints fC = new GridBagConstraints();
		fC.fill = GridBagConstraints.BOTH;
		fC.weighty = 1.0;
		fC.weightx = 1;
		fC.gridx = 2;
		fC.gridy = 0;
		fC.gridwidth = 1;
		fC.gridheight = 1;
		JScrollPane jScrollPane = new JScrollPane(textArea);
		jScrollPane.setAlignmentX(LEFT_ALIGNMENT);
		jScrollPane.setAutoscrolls(false);
		jScrollPane
				.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
		
		getContentPane().add(jScrollPane, fC);

		JButton jb = new JButton();
		jb.setText("Escenario 1 - Normal");
		jb.addActionListener(this);
		JButton jb2 = new JButton();
		jb2.addActionListener(this);
		jb2.setText("Escenario 2 - Obstaculos");
		JButton jb3 = new JButton();
		jb3.addActionListener(this);
		jb3.setText("Escenario 3 - Viento");
		
		fC.gridx = 0;
		fC.gridy = 1;
		fC.weighty = 0;
		fC.gridheight = 1;
		fC.gridwidth = 1;
		getContentPane().add(jb, fC);
		fC.gridx = 1;
		fC.gridy = 1;
		fC.gridheight = 1;
		fC.gridwidth = 1;
		getContentPane().add(jb2, fC);
		fC.gridx = 2;
		fC.gridy = 1;
		fC.gridheight = 1;
		fC.gridwidth = 1;
		getContentPane().add(jb3, fC);
		
	}

	private void calcularTextArea() {
		textArea.setText("");
		textArea.setColumns(10);
		Font newFont = getFont().deriveFont(1);
		textArea.setCaretColor(Color.black);
		textArea.setFont(newFont);
		StringBuilder sb = new StringBuilder();
		
		if (simulador.getEscenario() == 1){	
			sb.append("Escenario elegido: Normal");
		} else if (simulador.getEscenario() == 2) {
			sb.append("Escenario elegido: Obstaculos");
		} else {
			sb.append("Escenario elegido: Viento");
		}
		sb.append(Configuracion.SEPARADOR);
		sb.append(SEPARADOR2);
		sb.append(Configuracion.SEPARADOR);
		sb.append("Cant. de recipientes grua: ");
		sb.append(simulador.getServicioSistemaGrua().getCantidadRecipientes());
		sb.append(Configuracion.SEPARADOR);
		sb.append("Cant. de recipientes deposito: ");
		sb.append(simulador.getServicioDepositoAlmacenamiento().getCantidadRecipientes());
		sb.append(Configuracion.SEPARADOR);
		sb.append(SEPARADOR2);
		List<Carro> carros = simulador.getListCarro();

		for (Carro carro : carros){
			sb.append(Configuracion.SEPARADOR);
			sb.append("Carro " + carro.getId());
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Color: ");
			switch (carro.getId().intValue()) {
			case(1):
				sb.append("Rojo");
				break;
			case(2):
				sb.append("Verde");
				break;
			case(3):
				sb.append("Azul");
				break;
			}
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Orden: " + carro.getOrden().getValor());
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Sobre: "+ carro.getInfraestructura().getTipo());
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Velocidad: " + carro.getVelocidad());
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Sentido: " + carro.getSentido().getValor());
			sb.append(Configuracion.SEPARADOR);
			sb.append("    Estado: " + (carro.getRecipiente() == null ? " Vacio" : " Cargado"));
			sb.append(Configuracion.SEPARADOR);
			if (carro.getSensor().getListEvento() != null) {
				for (Evento e : carro.getSensor().getListEvento()){
					if (e.getTipoEvento() == EnumEvento.VIENTO){
						int id = carro.getId().intValue();
						sb.append(Configuracion.SEPARADOR);
						sb.append(">> Se detecto viento de "+e.getValor()+" en el carro " + id);
						sb.append(Configuracion.SEPARADOR);
					} 
				}
			}
			sb.append(SEPARADOR2);
		}
		textArea.setText(sb.toString());
		
		StringBuilder sb2 = new StringBuilder();
		List<Camino> listCaminos = simulador.getListCaminos();
		if (listCaminos != null) {
			for (Camino cam : listCaminos) {
				if (cam.getSensor().getListEvento() != null) {
					for (Evento e : cam.getSensor().getListEvento()){
						if (e.getTipoEvento() == EnumEvento.OBSTACULO){
							int id = cam.getId().intValue();
							sb2.append(Configuracion.SEPARADOR);
							sb2.append(">> Camino " + id + " bloqueado");
						} 
					}
				}
			}

		}
		textArea.setCaretColor(Color.red);
		textArea.append(sb2.toString());
	}

	private GridBagConstraints agregarPanelSimulacion(GridBagLayout layOut) {
		GridBagConstraints fC = new GridBagConstraints();
		fC.fill = GridBagConstraints.BOTH;
		fC.weightx = 1.0;
		fC.weighty = 1.0;
		fC.gridx = 0;
		fC.gridy = 0;
		fC.gridwidth = 2;
		fC.gridheight = 1;
		comp = new SimulacionPanel(simulador);
		getContentPane().add(comp, fC);
		return null;
	}

	private void agregarTitulos(GridBagLayout layOut) {
		GridBagConstraints fC = new GridBagConstraints();
		fC.weightx = 1.0;
		fC.gridwidth = GridBagConstraints.RELATIVE;
		JLabel statusLabel = new JLabel();
		statusLabel.setText("Estado");
		Font newFont = getFont().deriveFont(1);
		statusLabel.setFont(newFont);
		statusLabel.setHorizontalAlignment(JLabel.CENTER);
		getContentPane().add(statusLabel, fC);

		GridBagConstraints fC2 = new GridBagConstraints();
		fC2.weightx = 1.0;
		fC2.gridwidth = GridBagConstraints.REMAINDER;
		JLabel infoLabel = new JLabel();
		infoLabel.setText("Informacion");
		newFont = getFont().deriveFont(1);
		infoLabel.setFont(newFont);
		infoLabel.setHorizontalAlignment(JLabel.CENTER);
		getContentPane().add(infoLabel, fC2);
	}

	private JLabel addInfo(GridBagLayout layOut2, JPanel jp, Carro carro) {

		GridBagConstraints fC2 = new GridBagConstraints();
		fC2.fill = GridBagConstraints.BOTH;
		fC2.weightx = 1.0;
		fC2.weighty = 1.0;
		fC2.gridwidth = GridBagConstraints.RELATIVE;

		JLabel textFieldLabel = new JLabel("Carro");
		layOut2.setConstraints(textFieldLabel, fC2);
		jp.add(textFieldLabel);

		GridBagConstraints fCReminder = new GridBagConstraints();
		fCReminder.fill = GridBagConstraints.BOTH;
		fCReminder.weightx = 1.0;
		fCReminder.weighty = 1.0;
		fCReminder.gridwidth = GridBagConstraints.REMAINDER;

		JLabel textFieldLabel2 = new JLabel(String.valueOf(carro.getSensor()
				.getVelocidadViento()));
		layOut2.setConstraints(textFieldLabel2, fCReminder);
		jp.add(textFieldLabel2);

		return textFieldLabel2;
	}

	public void actionPerformed(ActionEvent e) {
		for (Sensor sensor : simulador.getListSensor()){
			if (sensor.getListEvento() != null){
				sensor.getListEvento().clear();
			}
		}
		if (e.getActionCommand().equals("Escenario 1 - Normal")) {
			simulador.setEscenario(Configuracion.ESCENARIO_UNO_NORMAL);
		} else if (e.getActionCommand().equals("Escenario 2 - Obstaculos")) {
			simulador.setEscenario(Configuracion.ESCENARIO_DOS_OBSTACULO);
		} else if (e.getActionCommand().equals("Escenario 3 - Viento")) {
			simulador.setEscenario(Configuracion.ESCENARIO_TRES_VIENTO);
		}

	}


	private static class SimulacionPanel extends JPanel {
		private Simulador simulador;
		private static int offset = 0;
		private static boolean up = true;
		private static final long serialVersionUID = 1L;
		public static final int GROSOR_TRAZO = 5;
		public static final double CARRO_SIZE = 30;
		public static final int yOffset = 110;
		public static final int alto = 300; // camino ppal
		public static final int ancho = 300; // ancho camino horizontal
		public static final int altoSubCamino = 100;
		public static final int anchoCompuerta = 60;
		private Color colorEsclusaCentroUp;
		private Color colorEsclusaCentroDown;
		private Color colorEsclusaDerechaUp;
		private Color colorEsclusaDerechaDown;
		private Color colorEsclusaIzquierdaUp;
		private Color colorEsclusaIzquierdaDown;

		public SimulacionPanel() {
		}

		public SimulacionPanel(Simulador simulador) {
			this.simulador = simulador;
		}

		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			Graphics2D g2 = (Graphics2D) g;

			Dimension d = getSize();
			int w = d.width;
			int h = d.height;

			// Creates the buffered image.
			BufferedImage buffImg = new BufferedImage(w, h,
					BufferedImage.TYPE_INT_ARGB);
			Graphics2D gbi = buffImg.createGraphics();

			// Clears the previously drawn image.
			g2.setColor(Color.white);
			g2.fillRect(0, 0, d.width, d.height);

			List<Esclusa> listEsclusa = simulador.getListEsclusa();
			for (Esclusa esclusa : listEsclusa) {
				int id = esclusa.getId().intValue();
				boolean abierta = esclusa.isAbierta();
				switch (id) {
				case 1:
					colorEsclusaIzquierdaDown = (abierta ? Color.yellow
							: Color.black);
					break;
				case 2:
					colorEsclusaIzquierdaUp = (abierta ? Color.yellow
							: Color.black);
					break;
				case 3:
					colorEsclusaCentroDown = (abierta ? Color.yellow
							: Color.black);
					break;
				case 4:
					colorEsclusaCentroUp = (abierta ? Color.yellow
							: Color.black);
					break;
				case 5:
					colorEsclusaDerechaDown = (abierta ? Color.yellow
							: Color.black);
					break;
				case 6:
					colorEsclusaDerechaUp = (abierta ? Color.yellow
							: Color.black);
					break;
				}
			}

			dibujarMapa(gbi, w, h);
			List<Carro> listCarro = simulador.getListCarro();
			for (Carro carro : listCarro) {
				dibujarCarro(gbi, carro, w, h);
			}

			// Draws the buffered image.
			g2.drawImage(buffImg, null, 0, 0);
		}

		private void dibujarSensores(Graphics2D gbi, int w, int h) {
			int centro = w / 2;
			int diametro = 20;
			gbi.setColor(new Color(0.0f, 0.0f, 0.0f, 1.0f));
			// arriba
			gbi.fillOval(centro - (diametro / 2) + (GROSOR_TRAZO / 2), yOffset
					- (diametro / 2), diametro, diametro);
			// interseccion ppal
			gbi.fillOval(centro - (diametro / 2) + (GROSOR_TRAZO / 2), alto
					+ yOffset - (diametro / 2), diametro, diametro);
			// interseccion ppal izq
			gbi.fillOval(centro - (diametro / 2) - (altoSubCamino / 2)
					+ (GROSOR_TRAZO / 2), alto + yOffset - (diametro / 2),
					diametro, diametro);
			// interseccion ppal izq
			gbi.fillOval(centro - (diametro / 2) + (altoSubCamino / 2)
					+ (GROSOR_TRAZO / 2), alto + yOffset - (diametro / 2),
					diametro, diametro);
			// abajo centro
			gbi.fillOval(centro - (diametro / 2) + (GROSOR_TRAZO / 2), alto
					+ yOffset + altoSubCamino - (diametro / 2), diametro,
					diametro);
			// abajo izq
			gbi.fillOval(centro - (ancho / 2) - (GROSOR_TRAZO) - 2, alto
					+ yOffset + altoSubCamino - (diametro / 2), diametro,
					diametro);
			// abajo der
			gbi.fillOval(centro + (ancho / 2) - (GROSOR_TRAZO) - 2, alto
					+ yOffset + altoSubCamino - (diametro / 2), diametro,
					diametro);

			// descanso arriba
			gbi.fillOval(centro - (diametro / 2) + (GROSOR_TRAZO / 2), alto
					- (diametro / 2) + yOffset - altoSubCamino / 2, diametro,
					diametro);

			// descanso abajo
			gbi.fillOval(centro - (diametro / 2) + (GROSOR_TRAZO / 2), alto
					- (diametro / 2) + altoSubCamino / 2 + yOffset, diametro,
					diametro);

		}

		private void dibujarCarro(Graphics2D gbi, Carro carro, int w, int h) {
			int centro = w / 2;

			double x = carro.getPosicion().getX();
			double y = carro.getPosicion().getY();
			// System.out.println(x + " " + y);

			Infraestructura infra = carro.getInfraestructura();
			String tipo = infra.getTipo();
			Camino camino = null;
			Descanso descanso = null;
			if (tipo.equals("Descanso")) {
				descanso = (Descanso) infra;
				switch (descanso.getId().intValue()) {
				case (1):
					x = centro - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = -(y * 5) + yOffset + alto + (altoSubCamino / 2)
							- (CARRO_SIZE / 2);
					break;
				case (2):
					x = -(x * 5) + centro - (CARRO_SIZE / 2);
					y = yOffset + alto + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					break;
				case (3):
					x = (x * 5) + centro - (CARRO_SIZE / 2);
					y = yOffset + alto + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					break;
				case (4):
					x = centro + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = -(y * 5) + yOffset + alto + (altoSubCamino / 2)
							- (CARRO_SIZE / 2);
					break;
				case (5):
					x = centro + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = -(y * 5) + yOffset + alto - (CARRO_SIZE / 2);
					break;
				case (6):
					x = -(x * 5) + centro + (altoSubCamino / 2)
							- (CARRO_SIZE / 2);
					y = yOffset + alto - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					break;
				case (7):
					x = (x * 5) + centro - (altoSubCamino / 2)
							- (CARRO_SIZE / 2) + 5;
					y = yOffset + alto - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					break;
				case (8):
					x = centro - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = -(y * 5) + yOffset + alto - (CARRO_SIZE / 2);
					break;
				}
			} else if (tipo.equals("Camino")) {
				// vertical Izq
				camino = (Camino) infra;
				if (camino.getId() == 1) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2));
				}
				// vertical Medio
				if (camino.getId() == 2) {
					x = (centro - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2));
				}
				// vertical Der
				if (camino.getId() == 3) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2));
				}
				// horizontal desde izq
				if (camino.getId() == 4) {
					// System.out.println("---------" + x);
					x = (x * 15) + centro - (ancho / 2);
					y = (-10 * y) + (alto + yOffset) - (CARRO_SIZE / 2);
				}
				// horizontal desde der
				if (camino.getId() == 5) {
					// System.out.println("---------" + x);
					x = (centro + (ancho / 2)) - (x * 15) - (CARRO_SIZE);
					y = (-10 * y) + (alto + yOffset) - (CARRO_SIZE / 2);
				}

				// vertical de arriba
				if (camino.getId() == 6) {
					x = centro - (CARRO_SIZE / 2);
					y = (-10 * y) + (alto + yOffset) - (CARRO_SIZE / 2);
				}
			} else if (tipo.equals("Esclusa")) {
				int esclusaArriba = 20;
				int esclusaAbajo = 30;
				if (carro.getSentido() == EnumSentido.HACIA_DEPOSITO) {
					esclusaArriba = 0;
					esclusaAbajo = 20;
				}
				if (infra.getId() == 1) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaAbajo;
				} else if (infra.getId() == 2) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaArriba;
				}
				if (infra.getId() == 3) {
					x = (centro - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaAbajo;
				} else if (infra.getId() == 4) {
					x = (centro - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaArriba;
				}
				if (infra.getId() == 5) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaAbajo;
				} else if (infra.getId() == 6) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (-10 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ esclusaArriba;
				}
			} else if (tipo.equals("Compuerta")) {
				if (infra.getId() == 1) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (-1 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ 20;
				}
				if (infra.getId() == 2) {
					x = (centro - (CARRO_SIZE / 2));
					y = (-1 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ 20;
				}
				if (infra.getId() == 3) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (-1 * y)
							+ (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2))
							+ 20;
				}
			} else if (tipo.equals("Punto")) {
				if (infra.getId() == 1) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (alto + yOffset) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 2) {
					x = centro - (CARRO_SIZE / 2);
					y = (alto + yOffset) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 3) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (alto + yOffset) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 4) {
					x = centro - (CARRO_SIZE / 2);
					y = yOffset - (CARRO_SIZE / 2);
				}
				// -------------------------------------------------------------
				if (infra.getId() == 5) {
					x = centro - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 6) {
					x = centro - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 7) {
					x = centro - (CARRO_SIZE / 2);
					y = yOffset + alto + (altoSubCamino / 2) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 8) {
					x = centro + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto + (altoSubCamino / 2) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 9) {
					x = centro + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 10) {
					x = centro + (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto - (altoSubCamino / 2) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 11) {
					x = centro - (CARRO_SIZE / 2);
					y = yOffset + alto - (altoSubCamino / 2) - (CARRO_SIZE / 2);
				}
				if (infra.getId() == 12) {
					x = centro - (altoSubCamino / 2) - (CARRO_SIZE / 2);
					y = yOffset + alto - (altoSubCamino / 2) - (CARRO_SIZE / 2);
				}
			} else if (tipo.equals("Deposito")) {
				if (carro.getId() == 1) {
					x = (centro - (ancho / 2) - (CARRO_SIZE / 2));
					y = (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2)) + 30;
				}
				// vertical Medio
				if (carro.getId() == 2) {
					x = (centro - (CARRO_SIZE / 2));
					y = (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2)) + 30;
				}
				// vertical Der
				if (carro.getId() == 3) {
					x = (centro + (ancho / 2) - (CARRO_SIZE / 2));
					y = (alto + yOffset + altoSubCamino - (CARRO_SIZE / 2)) + 30;
				}
			} else {
				System.out.println("------------------------>-----------> "
						+ tipo + infra.getId());
			}

			String valorViento = "";
			List<Evento> listEvento = carro.getSensor().getListEvento();
			if (listEvento != null){
				for (Evento evento : listEvento){
					if (evento.getTipoEvento() == EnumEvento.VIENTO){
						valorViento = evento.getValor();
					}
				}
			}

			if (!valorViento.equals("")){
				gbi.setColor(Color.PINK);
				gbi.setComposite(AlphaComposite
						.getInstance(AlphaComposite.SRC_OVER));
				gbi.fillRect((int)x - 4, (int)y - 4, (int)CARRO_SIZE +8, (int)CARRO_SIZE+8);				
			}
						
			gbi.setColor(carro.getColor());
			gbi.setComposite(AlphaComposite
					.getInstance(AlphaComposite.SRC_OVER));
			
			gbi.fill(new Rectangle2D.Double(x, y, CARRO_SIZE, CARRO_SIZE));
			if (carro.getRecipiente() != null) {
				gbi.setColor(Color.white);
				gbi.fillOval((int) x + 8, (int) y + 8, 15, 15);
			}

		}

		private void dibujarMapa(Graphics2D gbi, int w, int h) {
			gbi.setColor(new Color(0.0f, 0.0f, 0.0f, 1.0f));
			int centro = w / 2;
			int posicionYSubcamino = alto + yOffset;

			Color color1 = Color.black;
			Color color2 = Color.black;
			Color color3 = Color.black;
			Color color4 = Color.black;
			Color color5 = Color.black;
			Color color6 = Color.black;
			List<Camino> listCaminos = simulador.getListCaminos();
			for (Camino camino : listCaminos) {
				if (camino.getSensor().getListEvento() != null) {
					for (Evento e : camino.getSensor().getListEvento()) {
						Color color = Color.black;
						if (e.getTipoEvento() == EnumEvento.OBSTACULO) {
							color = Color.red;
						}
						int id = camino.getId().intValue();
						switch (id) {
						case 1:
							color1 = color;
							break;
						case 2:
							color2 = color;
							break;
						case 3:
							color3 = color;
							break;
						case 4:
							color4 = color;
							break;
						case 5:
							color5 = color;
							break;
						case 6:
							color6 = color;
							break;
						}
					}
				}
			}
			gbi.setColor(color6);
			gbi.fill(new Rectangle2D.Double(centro, yOffset, GROSOR_TRAZO, alto)); // vertical
			// h
			gbi.setColor(color4);
			gbi.fill(new Rectangle2D.Double(centro - (ancho / 2),
					posicionYSubcamino, ancho / 2, GROSOR_TRAZO));
			gbi.setColor(color5);
			gbi.fill(new Rectangle2D.Double(centro - (ancho / 2) + ancho / 2,
					posicionYSubcamino, ancho / 2, GROSOR_TRAZO));
			gbi.setColor(color1);
			// v izq
			gbi.fill(new Rectangle2D.Double(centro - (ancho / 2),
					posicionYSubcamino, GROSOR_TRAZO, altoSubCamino));
			gbi.setColor(color2);
			// v cent
			gbi.fill(new Rectangle2D.Double(centro, posicionYSubcamino,
					GROSOR_TRAZO, altoSubCamino));
			gbi.setColor(color3);
			// v der
			gbi.fill(new Rectangle2D.Double(centro + (ancho / 2),
					posicionYSubcamino, GROSOR_TRAZO, altoSubCamino));

			// h izq 1
			Rectangle2D.Double esclusaIzquierdaUp = new Rectangle2D.Double(
					centro - (ancho / 2) - (anchoCompuerta / 2), alto
							+ altoSubCamino + yOffset, anchoCompuerta,
					GROSOR_TRAZO);
			// h izq 2
			Rectangle2D.Double esclusaIzquierdaDown = new Rectangle2D.Double(
					centro - (ancho / 2) - (anchoCompuerta / 2), alto
							+ altoSubCamino + yOffset + 20, anchoCompuerta,
					GROSOR_TRAZO);

			gbi.setColor(colorEsclusaIzquierdaUp);
			gbi.fill(esclusaIzquierdaUp);

			gbi.setColor(colorEsclusaIzquierdaDown);
			gbi.fill(esclusaIzquierdaDown);

			// horiz central 1
			Rectangle2D.Double esclusaCentroUp = new Rectangle2D.Double(centro
					- (anchoCompuerta / 2), alto + altoSubCamino + yOffset,
					anchoCompuerta, GROSOR_TRAZO);
			// horiz central 2
			Rectangle2D.Double esclusaCentroDown = new Rectangle2D.Double(
					centro - (anchoCompuerta / 2), alto + altoSubCamino
							+ yOffset + 20, anchoCompuerta, GROSOR_TRAZO);

			gbi.setColor(colorEsclusaCentroUp);
			gbi.fill(esclusaCentroUp);
			gbi.setColor(colorEsclusaCentroDown);
			gbi.fill(esclusaCentroDown);

			// h der 1
			Rectangle2D.Double esclusaDerechaUp = new Rectangle2D.Double(centro
					+ (ancho / 2) - (anchoCompuerta / 2), alto + altoSubCamino
					+ yOffset, anchoCompuerta, GROSOR_TRAZO);
			// h der 1
			Rectangle2D.Double esclusaDerechaDown = new Rectangle2D.Double(
					centro + (ancho / 2) - (anchoCompuerta / 2), alto
							+ altoSubCamino + yOffset + 20, anchoCompuerta,
					GROSOR_TRAZO);
			gbi.setColor(colorEsclusaDerechaUp);
			gbi.fill(esclusaDerechaUp);
			gbi.setColor(colorEsclusaDerechaDown);
			gbi.fill(esclusaDerechaDown);
			gbi.setColor(new Color(0.0f, 0.0f, 0.0f, 1.0f));
			Rectangle2D.Double rec = new Rectangle2D.Double(centro
					- (altoSubCamino / 2),
					yOffset + alto - (altoSubCamino / 2), altoSubCamino,
					altoSubCamino);
			float[] dash2 = { 5f, 5f, 5f };
			gbi.setStroke(new BasicStroke(3, BasicStroke.CAP_SQUARE,
					BasicStroke.JOIN_MITER, 1f, dash2, 6f));
			gbi.draw(rec);

			dibujarSensores(gbi, w, h);
		}
	}

}
